/**
 * 注册、登录、注销
 * */
import util from '@/libs/util';
import store from '@/store/index';
import router from '@/router';
import { robotindexwxids } from '@/api/account.js';
import {
    AccountLogin,
    AccountdingLogin,
    AccountRegister,
    GetMenus,
    dingLoginAccount,
    AccountLogout
} from '@api/account';
// import base64 from '@/libs/base64.js';
import * as $websocket from '@/plugins/request/chatwebsocket';

import { Modal } from 'view-design';
// 方法
import { getMenuSider } from '@/libs/system';
export default {
    namespaced: true,
    state: {
        //关闭弹窗是否刷新
        closeRefresh:false,
        loginInfo: {} // 登陆信息，用语断线重连
    },
    mutations: {
        SET_LOGIN_INFO: (state, info) => {
            state.loginInfo = info;
        },
         /**
         更新弹窗关闭是否刷新参数
         */
        changeCloseRefresh (state,type) {
            state.closeRefresh =type
        }
    },
    getters: {
        loginInfo: state => {
            return state.loginInfo;
        },
        getCloseRefesh(state){
            return state.closeRefesh
        }
    },
    actions: {
        /**
         * @description 登录
         * @param {Object} param context
         * @param {Object} param username {String} 用户账号
         * @param {Object} param password {String} 密码
         * @param {Object} param route {Object} 登录成功后定向的路由对象 任何 vue-router 支持的格式
         */
        SetLoginInfo({ commit }, info) {
            commit('SET_LOGIN_INFO', info);
        },
        login({ dispatch }, { username = '', password = '' } = {}) {
            return new Promise((resolve, reject) => {
                // 开始请求登录接口
                AccountLogin({
                    username,
                    password
                })
                    .then(async res => {
                        // let loginInfo = localStorage.getItem('loginInfo')
                        localStorage.clear();
                        // 密码存储到cookies中base64加密存储
                        let enc = window.btoa(password); // 编码成base64的
                        // let dec = window.atob(enc) //把base64解码
                        // var res = '编码字符串为: ' + enc + '<br>' + '解码后字符串为: ' + dec
                        // console.log(res)
                        util.cookies.set('username', username);
                        util.cookies.set('password', enc);
                        // localStorage.setItem('loginInfo', loginInfo)
                        // 设置 cookie 一定要存 uuid 和 token 两个 cookie
                        // 整个系统依赖这两个数据进行校验和存储
                        // uuid 是用户身份唯一标识 用户注册的时候确定 并且不可改变 不可重复
                        // token 代表用户当前登录状态 建议在网络请求中携带 token
                        // 如有必要 token 需要定时更新，默认保存一天，可在 setting.js 中修改
                        // 如果你的 token 不是通过 cookie 携带，而是普通字段，也可视情况存储在 localStorage
                        util.cookies.set('uuid', res.info.member_id);
                        util.cookies.set('token', res.access_token);
                        localStorage.setItem('userinfo', JSON.stringify(res.info));
                        localStorage.setItem('TriggerFriendPushTask', JSON.stringify(true));
                        // 设置 vuex 用户信息
                        await dispatch('admin/user/set', res.info, {
                            root: true
                        });
                        // 用户登录后从持久化数据加载一系列的设置
                        await dispatch('load');
                        // 结束
                        resolve(res);
                    })
                    .catch(err => {
                        // console.log('err: ', err);
                        reject(err);
                    });
            });
        },
        logins({ dispatch }, { user_id = '' } = {}) {
            return new Promise((resolve, reject) => {
                // 开始请求登录接口
                AccountdingLogin({
                    user_id
                })
                    .then(async res => {
                        let username = util.cookies.get('username');
                        let password = util.cookies.get('password');
                        // let loginInfo = localStorage.getItem('loginInfo')
                        localStorage.clear();
                        // localStorage.setItem('loginInfo', loginInfo)
                        let enc = window.btoa(password); // 编码成base64的
                        // let dec = window.atob(enc) //把base64解码
                        // var res = '编码字符串为: ' + enc + '<br>' + '解码后字符串为: ' + dec
                        // console.log(res)
                        util.cookies.set('username', username);
                        util.cookies.set('password', enc);
                        // 设置 cookie 一定要存 uuid 和 token 两个 cookie
                        // 整个系统依赖这两个数据进行校验和存储
                        // uuid 是用户身份唯一标识 用户注册的时候确定 并且不可改变 不可重复
                        // token 代表用户当前登录状态 建议在网络请求中携带 token
                        // 如有必要 token 需要定时更新，默认保存一天，可在 setting.js 中修改
                        // 如果你的 token 不是通过 cookie 携带，而是普通字段，也可视情况存储在 localStorage
                        util.cookies.set('uuid', res.info.member_id);
                        util.cookies.set('token', res.access_token);
                        localStorage.setItem('userinfo', JSON.stringify(res.info));
                        localStorage.setItem('TriggerFriendPushTask', JSON.stringify(true));
                        // 设置 vuex 用户信息
                        await dispatch('admin/user/set', res.info, {
                            root: true
                        });
                        // 用户登录后从持久化数据加载一系列的设置
                        await dispatch('load');
                        // 结束
                        resolve(res);
                    })
                    .catch(err => {
                        // console.log('err: ', err);
                        reject(err);
                    });
            });
        },
        /**
         * 菜单获取
         */
        getmenu({ dispatch }, id) {
            return new Promise((resolve, reject) => {
                // 开始请求登录接口
                GetMenus({
                    project_id: id
                })
                    .then(async res => {
                        // console.log(res);
                        // localStorage.setItem('is_role_kf', res.is_role_kf)
                        // localStorage.setItem('is_nurse', res.is_nurse)
                        // localStorage.setItem('is_role_yz', res.is_role_yz)
                        localStorage.setItem('menus', JSON.stringify(res.auth));
                        localStorage.setItem(
                            'attr_list',
                            JSON.stringify(res.attr_list)
                        );
                        localStorage.setItem(
                            'project',
                            JSON.stringify(res.project)
                        );
                        localStorage.setItem(
                            'currentProject',
                            res.defaultProjectId
                        );
                        const filterMenuSider = getMenuSider(
                            res.auth.sider,
                            res.defaultProjectId
                        );
                        for (let item of res.auth.action) {
                            store.commit('power/power/setEditpower', item);
                        }
                        localStorage.setItem(
                            'poweredit',
                            JSON.stringify(store.state.power.power.poweredit)
                        );
                        store.commit('admin/menu/setHeader', res.auth.header);
                        store.commit('admin/menu/setSider', filterMenuSider);
                        store.commit('admin/menu/setProject', res.project);
                        store.commit(
                            'admin/menu/setCurrentProject',
                            res.defaultProjectId
                        );
                        let r = await robotindexwxids();
                        localStorage.setItem('wechatInfo', r);
                        resolve();
                    })
                    .catch(err => {
                        reject(err);
                    });
            });
        },

        /**
         * @description 退出登录
         * */
        logout({ commit, dispatch }, { confirm = false, vm } = {}) {
            if (confirm) {
                // console.log(confirm,'qq');
                Modal.confirm({
                    title: vm.$t('basicLayout.logout.confirmTitle'),
                    content: vm.$t('basicLayout.logout.confirmContent'),
                    onOk() {
                        return new Promise((resolve,reject) => {
                            AccountLogout().then(async res => {
                                resolve(res);
                                // 删除cookie
                                util.cookies.remove('token');
                                util.cookies.remove('uuid');
                                
                                   // 清空 vuex 用户信息
                                await dispatch('admin/user/set', {}, { root: true });
                                  // 跳转路由
                                  router.push({
                                    name: 'login'
                                });
                                    // 清空选中微信
                                store.commit('chatwebsocket/wechat/setCurrentConversationId', '');
                                store.commit('chatwebsocket/wechat/SET_CURRENT_WECHAT', {});
                                // 清空选中好友
                                store.commit('chatwebsocket/wechat/setCurrentFriend', {});
                                // 清空好友列表
                                store.commit('chatwebsocket/wechat/SET_CURRENT_CONVERS', []);
                                // 清空聊天记录
                                store.commit('chatwebsocket/wechat/clearnChatMessages');
                                let user = JSON.parse(window.localStorage.getItem('wsInfo'));
                                if (user) {
                                    let msg = { MsgType: 'AccountLogoutNotice', Content: { UnionId: user.SetUser.UnionId, AccountType: 2 } };
                                    vm.$websocket.sendSock(msg);
                                }
                             
                                let loginInfo = localStorage.getItem('loginInfo');
                                localStorage.clear();
                                localStorage.setItem('loginInfo', loginInfo);
                                $websocket.closeWebsocket();
                                //
                                store.dispatch('admin/page/closeAll');
                                // store.commit('websocket/account/SetRelogin', true);
                            }).catch(err => {
                                    reject(err);
                                    // 跳转路由
                                    //  router.push({
                                    //     name: 'login'
                                    // });
                                });
                        });
                       
                    }
                });
            } else {
                return new Promise((resolve,reject) => {
                    AccountLogout().then(async res => {
                        resolve(res);
                        // 删除cookie
                        util.cookies.remove('token');
                        util.cookies.remove('uuid');
                        
                           // 清空 vuex 用户信息
                        await dispatch('admin/user/set', {}, { root: true });
                          // 跳转路由
                          router.push({
                            name: 'login'
                        });
                            // 清空选中微信
                        store.commit('chatwebsocket/wechat/setCurrentConversationId', '');
                        store.commit('chatwebsocket/wechat/SET_CURRENT_WECHAT', {});
                        // 清空选中好友
                        store.commit('chatwebsocket/wechat/setCurrentFriend', {});
                        // 清空好友列表
                        store.commit('chatwebsocket/wechat/SET_CURRENT_CONVERS', []);
                        // 清空聊天记录
                        store.commit('chatwebsocket/wechat/clearnChatMessages');
                        let user = JSON.parse(window.localStorage.getItem('wsInfo'));
                        if (user) {
                            let msg = { MsgType: 'AccountLogoutNotice', Content: { UnionId: user.SetUser.UnionId, AccountType: 2 } };
                            vm.$websocket.sendSock(msg);
                        }
                     
                        let loginInfo = localStorage.getItem('loginInfo');
                        localStorage.clear();
                        localStorage.setItem('loginInfo', loginInfo);
                        $websocket.closeWebsocket();
                        //
                        store.dispatch('admin/page/closeAll');
                    }).catch(err => {
                            reject(err);
                            // 跳转路由
                            //  router.push({
                            //     name: 'login'
                            // });
                        });
                });
               
            }
         
        },
        /**
         * @description 注册
         * @param {Object} param context
         * @param {Object} param mail {String} 邮箱
         * @param {Object} param password {String} 密码
         * @param {Object} param mobile {String} 手机号码
         * @param {Object} param captcha {String} 验证码
         */
        register(
            { dispatch },
            { mail = '', password = '', mobile = '', captcha = '' } = {}
        ) {
            return new Promise((resolve, reject) => {
                // 开始请求登录接口
                AccountRegister({
                    mail,
                    password,
                    mobile,
                    captcha
                })
                    .then(async res => {
                        // 注册成功后，完成与登录一致的操作
                        // 注册也可视情况不返还 uuid、token 等数据，在注册完成后，由前端自动执行一次登录逻辑
                        util.cookies.set('uuid', res.uuid);
                        util.cookies.set('token', res.access_token);
                        localStorage.setItem('userinfo', JSON.stringify(res.info));
                        localStorage.setItem('TriggerFriendPushTask', JSON.stringify(true));
                        // 设置 vuex 用户信息
                        await dispatch('admin/user/set', res.info, {
                            root: true
                        });
                        // 用户登录后从持久化数据加载一系列的设置
                        await dispatch('load');
                        // 结束
                        resolve();
                    })
                    .catch(err => {
                        // console.log('err: ', err);
                        reject(err);
                    });
            });
        },
        /**
         * @description 用户登录后从持久化数据加载一系列的设置
         * @param {Object} state vuex state
         * @param {Object} dispatch vuex dispatch
         */
        load({ state, dispatch }) {
            return new Promise(async resolve => {
                // 加载用户登录信息
                await dispatch('admin/user/load', null, { root: true });
                // 持久化数据加载上次退出时的多页列表
                await dispatch('admin/page/openedLoad', null, { root: true });
                /* $websocket.closeWebsocket();
                let token = util.cookies.get('token');
                let project_id = '';
                let userInfo = JSON.parse(localStorage.getItem('userinfo'));
                if(userInfo){
                    if(localStorage.getItem('currentProject') == null){
                        project_id = +userInfo.project_id;
                    }else{
                        project_id = localStorage.getItem('currentProject');
                    }
                    if (token && +userInfo.has_wechat_limit === 1) {
                        // 建立webwocket链接
                        $websocket.createWebSocket();
                    }else{
                        if(userInfo.wechat_limit_list){
                            for(const k in userInfo.wechat_limit_list) {
                                // console.log(k,'k');
                                if(k == project_id){
                                    if(userInfo.wechat_limit_list[k] === 1){
                                         // 建立webwocket链接
                                        $websocket.createWebSocket();
                                    }else{
                                        // 关闭webwocket链接
                                        $websocket.closeWebsocket();
                                    }
                                }
                            }
                        }
                    }
                }*/
           
                // end
                resolve();
            });
        },
        dingLogin({ dispatch }, code) {
            return new Promise((resolve, reject) => {
                // 开始请求登录接口
                dingLoginAccount({
                    code: code.code
                })
                    .then(async res => {
                        let loginInfo = localStorage.getItem('loginInfo');
                        localStorage.clear();
                        localStorage.setItem('loginInfo', loginInfo);
                        // 设置 cookie 一定要存 uuid 和 token 两个 cookie
                        // 整个系统依赖这两个数据进行校验和存储
                        // uuid 是用户身份唯一标识 用户注册的时候确定 并且不可改变 不可重复
                        // token 代表用户当前登录状态 建议在网络请求中携带 token
                        // 如有必要 token 需要定时更新，默认保存一天，可在 setting.js 中修改
                        // 如果你的 token 不是通过 cookie 携带，而是普通字段，也可视情况存储在 localStorage
                        util.cookies.set('uuid', res.info.member_id);
                        util.cookies.set('token', res.access_token);
                        localStorage.setItem('userinfo', JSON.stringify(res.info));
                        localStorage.setItem('TriggerFriendPushTask', JSON.stringify(true));
                        // 设置 vuex 用户信息
                        await dispatch('admin/user/set', res.info, {
                            root: true
                        });
                        // 用户登录后从持久化数据加载一系列的设置
                        await dispatch('load');
                        // 结束
                        resolve();
                    })
                    .catch(err => {
                        // console.log('err: ', err);
                        reject(err);
                    });
            });
        }
    }
};
